﻿using System;

namespace InheritedStudyApplication
{
    /*
     C# 继承
     继承是面向对象程序设计中最重要的概念之一。继承允许我们根据一个类来定义另一个类，这使得创建和维护应用程序变得更容易。同时也有利于重用代码和节省开发时间。
     当创建一个类时，程序员不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可。这个已有的类被称为的基类，这个新的类被称为派生类。
     基类和派生类
         一个类可以继承自另一个类，被称为基类（父类）和派生类（子类）。
         C# 不支持类的多重继承，但支持接口的多重继承，一个类可以实现多个接口。
         概括来说：一个类可以继承多个接口，但只能继承自一个类。
         C# 中创建派生类的语法如下：
            <访问修饰符> class <基类>
            {
                ..,
            }
            class <派生类> : <基类>
            {
                ...
            }
         派生类会继承基类的成员（字段、方法、属性等），除非它们被明确地标记为私有（private）。
         派生类可以通过关键字base来调用基类的构造函数和方法。
         class BaseClass
         {
            public void SomeMethod()
            {
                // Method implementation
            }
         }
         class DerviedClass : BaseClass
         {
            public void AnotherMethod()
            {
                base.SomeMethod();
            }
         }
     */
    class Shape
    {
        protected int width;
        protected int height;

        public void setWidth(int w)
        {
            width = w;
        }

        public void setHeight(int h)
        {
            height = h;
        }
    }

    class Rectangle1 : Shape
    {
        public int getArea()
        {
            return (width * height);
        }
    }

    class RectangleTester
    {
        public static void ExecuterRectangleTester()
        {
            Rectangle1 Rect = new Rectangle1();

            Rect.setWidth(5);
            Rect.setHeight(7);

            Console.WriteLine("总面积: {0}", Rect.getArea());
            Console.ReadKey();
        }
    }

    /*
     基类的初始化
     派生类继承了基类的成员变量和成员方法。因此父类对象应在子类对象创建之前被创建。您可以在成员初始化列表中进行父类的初始化。
     */
    class Rectangle2
    {
        protected double length;
        protected double width;

        public Rectangle2(double l, double w)
        {
            length = l;
            width = w;
        }

        public double GetArea()
        {
            return length * width;
        }

        public void Display()
        {
            Console.WriteLine("长度: {0}", length);
            Console.WriteLine("宽度: {0}", width);
            Console.WriteLine("面积: {0}", GetArea());
        }
    }

    class Tabletop : Rectangle2
    {
        private double cost;

        public Tabletop(double l, double w) : base(l, w)
        { }

        public double GetCost()
        {
            double cost;
            cost = GetArea() * 70;
            return cost;
        }

        public void Display()
        {
            base.Display();
            Console.WriteLine("成本: {0}", GetArea());
        }

        public static void ExecuteRectangle()
        {
            Tabletop t = new Tabletop(4.5, 7.5);
            t.Display();
            Console.ReadLine();
        }
    }

    /*
     继承接口
     一个接口可以继承自一个或多个其他接口，派生接口继承了基接口的所有成员。
     派生接口可以扩展基接口的成员列表，但不能改变它们的访问修饰符。
     如:
        interface IBaseInterface
        interface IDerivedInterface : IBaseInterface
     */
    interface IBaseInterface
    {
        void Method1();
    }

    interface IderivedInterface : IBaseInterface
    {
        void Method2();
    }

    class MyClass : IderivedInterface
    {
        public void Method1()
        {
            Console.WriteLine("Method1 implementation");
        }

        public void Method2()
        {
            Console.WriteLine("Method2 implementation");
        }

        public static void ExecuteMyClass()
        {
            MyClass obj = new MyClass();
            obj.Method1();
            obj.Method2();
        }
    }

    /*
     C# 多重继承
     多重继承指的是一个类别可以同时从多于一个父类继承行为与特征的功能。与单一继承相对，单一继承指一个类别只可以继承自一个父类。
     C# 不支持多重继承。但是，您可以使用接口来实现多重继承。
     */

    public interface PaintConst
    {
        int getCost(int area);
    }

    class Rectangle3 : Shape, PaintConst
    {
        public int getArea()
        {
            return (width * height);
        }

        public int getCost(int area)
        {
            return area * 70;
        }

        public static void ExecuteRectangleTester()
        {
            Rectangle3 Rect = new Rectangle3();
            int area;
            Rect.setWidth(5);
            Rect.setWidth(7);
            area = Rect.getArea();
            Console.WriteLine("总面积: {0}", Rect.getArea());
            Console.WriteLine("油漆总成本: ${0}", Rect.getCost(area));
            Console.ReadKey();
        }
    }
}